/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package Persistencia;

import LogicaNegocio.Especialista;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import LogicaNegocio.Turno;
import Persistencia.exceptions.NonexistentEntityException;
import Persistencia.exceptions.PreexistingEntityException;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 *
 * @author matii_000
 */
public class EspecialistaJpaController implements Serializable {

      public EspecialistaJpaController(EntityManagerFactory emf) {
            this.emf = emf;
      }
      private EntityManagerFactory emf = null;
      public EspecialistaJpaController(){
          emf=Persistence.createEntityManagerFactory("TrabajoFinalAvanzadaPU");
    }
    

      public EntityManager getEntityManager() {
            return emf.createEntityManager();
      }

      public void create(Especialista especialista)throws PreexistingEntityException, Exception {
            EntityManager em = null;
            try {
                  em = getEntityManager();
                  em.getTransaction().begin();
                  Turno unTurno = especialista.getUnTurno();
                  if (unTurno != null) {
                        unTurno = em.getReference(unTurno.getClass(), unTurno.getCodigo());
                        especialista.setUnTurno(unTurno);
                  }
                  em.persist(especialista);
                  if (unTurno != null) {
                        unTurno.getEspacialistas().add(especialista);
                        unTurno = em.merge(unTurno);
                  }
                  em.getTransaction().commit();
            } finally {
                  if (em != null) {
                        em.close();
                  }
            }
      }

      public void edit(Especialista especialista) throws NonexistentEntityException, Exception {
            EntityManager em = null;
            try {
                  em = getEntityManager();
                  em.getTransaction().begin();
                  Especialista persistentEspecialista = em.find(Especialista.class, especialista.getCodigo());
                  Turno unTurnoOld = persistentEspecialista.getUnTurno();
                  Turno unTurnoNew = especialista.getUnTurno();
                  if (unTurnoNew != null) {
                        unTurnoNew = em.getReference(unTurnoNew.getClass(), unTurnoNew.getCodigo());
                        especialista.setUnTurno(unTurnoNew);
                  }
                  especialista = em.merge(especialista);
                  if (unTurnoOld != null && !unTurnoOld.equals(unTurnoNew)) {
                        unTurnoOld.getEspacialistas().remove(especialista);
                        unTurnoOld = em.merge(unTurnoOld);
                  }
                  if (unTurnoNew != null && !unTurnoNew.equals(unTurnoOld)) {
                        unTurnoNew.getEspacialistas().add(especialista);
                        unTurnoNew = em.merge(unTurnoNew);
                  }
                  em.getTransaction().commit();
            } catch (Exception ex) {
                  String msg = ex.getLocalizedMessage();
                  if (msg == null || msg.length() == 0) {
                        int id = especialista.getCodigo();
                        if (findEspecialista(id) == null) {
                              throw new NonexistentEntityException("The especialista with id " + id + " no longer exists.");
                        }
                  }
                  throw ex;
            } finally {
                  if (em != null) {
                        em.close();
                  }
            }
      }

      public void destroy(int id) throws NonexistentEntityException {
            EntityManager em = null;
            try {
                  em = getEntityManager();
                  em.getTransaction().begin();
                  Especialista especialista;
                  try {
                        especialista = em.getReference(Especialista.class, id);
                        especialista.getCodigo();
                  } catch (EntityNotFoundException enfe) {
                        throw new NonexistentEntityException("The especialista with id " + id + " no longer exists.", enfe);
                  }
                  Turno unTurno = especialista.getUnTurno();
                  if (unTurno != null) {
                        unTurno.getEspacialistas().remove(especialista);
                        unTurno = em.merge(unTurno);
                  }
                  em.remove(especialista);
                  em.getTransaction().commit();
            } finally {
                  if (em != null) {
                        em.close();
                  }
            }
      }

      public List<Especialista> findEspecialistaEntities() {
            return findEspecialistaEntities(true, -1, -1);
      }

      public List<Especialista> findEspecialistaEntities(int maxResults, int firstResult) {
            return findEspecialistaEntities(false, maxResults, firstResult);
      }

      private List<Especialista> findEspecialistaEntities(boolean all, int maxResults, int firstResult) {
            EntityManager em = getEntityManager();
            try {
                  CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
                  cq.select(cq.from(Especialista.class));
                  Query q = em.createQuery(cq);
                  if (!all) {
                        q.setMaxResults(maxResults);
                        q.setFirstResult(firstResult);
                  }
                  return q.getResultList();
            } finally {
                  em.close();
            }
      }

      public Especialista findEspecialista(int id) {
            EntityManager em = getEntityManager();
            try {
                  return em.find(Especialista.class, id);
            } finally {
                  em.close();
            }
      }

      public int getEspecialistaCount() {
            EntityManager em = getEntityManager();
            try {
                  CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
                  Root<Especialista> rt = cq.from(Especialista.class);
                  cq.select(em.getCriteriaBuilder().count(rt));
                  Query q = em.createQuery(cq);
                  return ((Long) q.getSingleResult()).intValue();
            } finally {
                  em.close();
            }
      }
      
}
